package com.cgwx.commonutils;
/*
  @author GaoWei
 * @Date 2021/7/30 - 15:36
 */

import com.cgwx.commonutils.math.Expression;
import com.cgwx.commonutils.math.ExpressionTree;
import com.cgwx.commonutils.math.FuncMap;
import com.cgwx.commonutils.math.VarMap;
import io.swagger.annotations.Api;
import org.junit.Test;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.List;

/**
 * 数据类型转换工具类
 */
@Api(tags = "数据类型转换工具类")
public class DataTypeConvertUtils
{
    @Test
    public void test(){
        String s = "01010101";
        System.out.println(Binary_to_Dec(s));
    }

    /**
     * 二进制字符串转换为十进制字符串
     * @param s 二进制字符串，字符串中只能有0和1，否则会出现异常，字符串长度小于63，个数任意
     * @return 十进制字符串，长度超限或者字符为空返回0
     */
    public static String Binary_to_Dec(String s) {
        if ((s == null) || (s.equals(""))) {
            return "0";
        }
//        将二进制字符串前的‘0’全部去除
        while ((s.charAt(0) == '0') && (s.length() > 1)) {
            s = s.substring(1);
        }
//        64bit 8byte
        if (s.length() > 63) {
            return "0";
        }
        return String.valueOf(Long.valueOf(s, 2));
    }

    /**
     * 十进制字符串转换为二进制字符串
     * @param s 十进制字符串，长度任意，如果为负数，则返回其绝对值对应的二进制码，前加负号，如 2 -> 10; -2 -> -10
     * @return 二进制字符串
     */
    public static String Dec_to_Binary(String s){
        if ((s == null) || (s.equals(""))){
            return "0";
        }
        if (s.trim().charAt(0) == '-'){
            return "-" + Long.toBinaryString(Long.parseLong(s.trim().substring(1)));
        }
        return Long.toBinaryString(Long.parseLong(s.trim()));
    }

    /**
     * 二进制字符串转换为十六进制字符串（1个字节） 11111 -》 1F
     * @param s 二进制字符串(必须组成够完整的十六进制数，至少半个字节，是半个字节的整数倍)；修改代码后不需要满足此条件，任意即可，会在前面补0
     * @return 十六进制字符串
     */
    public static String Binary_to_Hex(String s) {
        if ((s == null) || (s.equals(""))){
            return "0";
        }
        if (s.trim().charAt(0) == '-') {
            return "-" + Long.toHexString(Long.valueOf(s.trim().substring(1), 2));
        }
        StringBuilder rtn_hex = new StringBuilder();
        if (s.length() % 8 != 0) {
            s = FullBinary(s, s.length() + 8 - s.length() % 8);
        }
        while (s.length() > 0) {
            rtn_hex.append(Long.toHexString(Long.valueOf(s.substring(0, 4).trim(), 2)));
            s = s.substring(4);
        }
        if (rtn_hex.length() % 2 == 1) {
            rtn_hex.insert(0, "0");
        }
        return rtn_hex.toString().toUpperCase();
    }

    /**
     * 十六进制字符串转换为二进制字符串
     * @param s 十六进制字符串
     * @return 二进制字符串
     */
    public static String Hex_to_Binary(String s)
    {
        if ((s == null) || (s.equals("")))
        {
            return "0";
        }
        if (s.trim().charAt(0) == '-')
        {
            return "-" + Long.toBinaryString(Long.valueOf(s.trim().substring(1), 16));
        }
        return Long.toBinaryString(Long.valueOf(s.trim(), 16));
    }

    /**
     * 十进制字符串转换为十六进制字符串(一个字节)
     * @param s 十进制字符串
     * @return 十六进制字符串
     */
    public static String Dec_to_Hex(String s)
    {
        if ((s == null) || (s.equals("")))
        {
            return "0";
        }
        String rtn_hex = Long.toHexString(Long.parseLong(s.trim())).toUpperCase();
        if (rtn_hex.length() % 2 != 0)
        {
            rtn_hex = "0" + rtn_hex;
        }
        return rtn_hex.toUpperCase();
    }

    /**
     * 十六进制字符串转换为十进制字符串 10 -》 16；0A -》 10；
     * @param hex 十六进制字符串
     * @return 十进制字符串
     */
    public static String Hex_to_Dec(String hex)
    {
        if ((hex == null) || (hex.equals("")))
        {
            return "0";
        }
        return String.valueOf(Long.valueOf(hex, 16));
    }

    /**
     * 整型数据取低8位为字节数据
     * @param i 整型数据
     * @return 字节数组，只有一个元素，低8位字节
     */
    public static byte[] int8_to_byte(int i)
    {
        byte[] res = new byte[1];
        res[0] = ((byte)i);
        return res;
    }

    /**
     * 字节数据转换为8位整型数据
     * @param bytes 字节数据（字节数组，只有一个元素）
     * @return 8位整型数据
     */
    public static int byte_to_int8(byte[] bytes)
    {
        return bytes[0] & 0xFF;
    }

    /**
     * 字节数据转为十六进制数
     * @param src 字节数据（传递字节数组数据）
     * @return 十六进制数据
     */
    public static String Byte_to_Hex(byte[] src)
    {
        StringBuilder stringBuilder = new StringBuilder();
        if ((src == null) || (src.length <= 0))
        {
            return null;
        }
        for (byte b : src)
        {
            int v = b & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2)
            {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    /**
     * 十六进制数据转换为字节数据
     * @param hexString 十六进制字符串
     * @return 字节数据（字节数组）
     */
    public static byte[] Hex_to_Byte(String hexString)
    {
        if ((hexString == null) || (hexString.equals("")))
        {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++)
        {
            int pos = i * 2;
            d[i] = ((byte)((byte)"0123456789ABCDEF".indexOf(hexChars[pos]) << 4 | (byte)"0123456789ABCDEF".indexOf(hexChars[(pos + 1)])));
        }
        return d;
    }

    /**
     * 十六进制数据转换为浮点型
     * @param hexString 十六进制字符串
     * @return 浮点型数据
     */
    public static float Hex_to_Float(String hexString)
    {
        return Float.intBitsToFloat((int)Long.parseLong(hexString, 16));
    }

    /**
     * 浮点型转换为十六进制数据
     * @param f 浮点型
     * @return 十六进制数据
     */
    public static String Float_to_Hex(float f)
    {
        return Integer.toHexString(Float.floatToIntBits(f));
    }

    /**
     * 十六进制数据转换为双精度浮点型
     * @param hexString 十六进制字符串
     * @return 双精度浮点型数据
     */
    public static double Hex_to_Double(String hexString)
    {
        BigInteger bi = new BigInteger(hexString, 16);
        return Double.longBitsToDouble(bi.longValue());
    }

    /**
     * 双精度浮点型转换为十六进制数据
     * @param d 双精度浮点型
     * @return 十六进制数据
     */
    public static String Double_to_Hex(double d)
    {
        return Long.toHexString(Double.doubleToLongBits(d));
    }

    /**
     * byte数组集合组成字节数据 {[43,56],[4,6]} -> [43, 56, 4, 6]
     * @param srcArrays byte数组集合
     * @return byte数组
     */
    public static byte[] combineByte(List<byte[]> srcArrays)
    {
        int len = 0;
        for (byte[] srcArray : srcArrays)
        {
            len += srcArray.length;
        }
        byte[] destArray = new byte[len];
        int destLen = 0;
        for (byte[] srcArray : srcArrays)
        {
            System.arraycopy(srcArray, 0, destArray, destLen, srcArray.length);
            destLen += srcArray.length;
        }
        return destArray;
    }

    /**
     * 拆分字节数组 [4, 6, 2, 3, 56, 78] start=2,end=5 -》 [2, 3, 56]，注意数组不要越界
     * @param b 待拆分的字节数组
     * @param start 开始的位数
     * @param end 结束的位数
     * @return 拆分完的字节数组
     */
    public static byte[] resolveByte(byte[] b, int start, int end)
    {
        byte[] dest = new byte[end - start];
        try
        {
            System.arraycopy(b, start, dest, 0, end - start);
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println("拆分数组下标越界");
            e.printStackTrace();
        }
        return dest;
    }

    /**
     * 将二进制字符串补全到len长（在前面补0，直到长度满足len）
     * @param binary 二进制字符串
     * @param len 补全后的字符串长度
     * @return 补全后的二进制字符串
     */
    public static String FullBinary(String binary, int len)
    {
        if (binary.length() < len)
        {
            return "0".repeat(len - binary.length()) +
                    binary;
        }
        return binary;
    }

    /**
     * 对原码字符串取反码
     *  正数：原码 = 反码
     *  负数：最高位不变，其余位取反（本方法中，是将各位直接取反，没有考虑符号位）
     * @param s 原码字符串
     * @return 反码字符串
     */
    public static String Get_Binary_Fm(String s)
    {
        if ((s == null) || (s.equals("")))
        {
            return "0";
        }
//        正数直接返回
        if (s.charAt(0) == '0')
        {
            return s;
        }
//        负数取反码（未考虑符号位）
        s = s.replaceAll("0", "2");
        s = s.replaceAll("1", "0");
        s = s.replaceAll("2", "1");
        return s;
    }

    /**
     * 对原码字符串取补码
     *   正数：原码 = 反码 = 补码
     *   负数：最高位不变，其余位取反（本方法中，是将各位直接取反，没有考虑符号位）+ 1
     * @param s 原码字符串
     * @return 补码字符串
     */
    public static String Get_Binary_Bm(String s)
    {
        if ((s == null) || (s.equals("")))
        {
            return "0";
        }
//        正数直接返回
        if (s.charAt(0) == '0')
        {
            return s;
        }
//        负数取补码（未考虑符号位）
        String dec_fm = Binary_to_Dec(Get_Binary_Fm(s));
        long fm = Long.parseLong(dec_fm) + 1L;
        return Dec_to_Binary(String.valueOf(fm));
    }

    /**
     * 低字节在前，高字节在后
     * @param str 待转换的字符串
     * @return 转换后的字符串
     */
    public static String LowUp(String str)
    {
        StringBuilder rtn_str = new StringBuilder();
        for (int i = str.length() / 2; i > 0; i--)
        {
            rtn_str.append(str, i * 2 - 2, i * 2);
        }
        return rtn_str.toString();
    }

    /**
     * 将二进制字符串补全到len长（在前面补0，直到长度满足len）
     * @param binary 二进制字符串
     * @param len 补全后的字符串长度
     * @return 补全后的二进制字符串
     */
    public static String FullStr0(String binary, int len)
    {
        if (binary.length() < len)
        {
            return "0".repeat(len - binary.length()) +
                    binary;
        }
        return binary;
    }

    /**
     * 16进制字符串，按字节，转换为其对应的ASCII字符，如61H -> 97 -> a; 即content = “6161” 转换完成后为 “aa”
     * @param content 待转换的16进制字符串
     * @return 转换完成的ASCII字符串
     */
    public static String AsciiStringToString(String content)
    {
        StringBuilder result = new StringBuilder();
        int length = content.length() / 2;
        for (int i = 0; i < length; i++)
        {
            String c = content.substring(i * 2, i * 2 + 2);
            int a = hexStringToAlgorism(c);
            char b = (char)a;
            String d = String.valueOf(b);
            result.append(d);
        }
        return result.toString();
    }

    /**
     * 将16进制字符串转换为10进制字符串
     * @param hex 十六进制字符串
     * @return 转换完成的十进制字符串
     */
    public static int hexStringToAlgorism(String hex)
    {
        hex = hex.toUpperCase();
        int max = hex.length();
        int result = 0;
        for (int i = max; i > 0; i--)
        {
            char c = hex.charAt(i - 1);
            int algorism;
            if ((c >= '0') && (c <= '9')) {
                algorism = c - '0';
            } else {
                algorism = c - '7';
            }
            result = (int)(result + Math.pow(16.0D, max - i) * algorism);
        }
        return result;
    }

    /**
     * 将字符串按字节加空格，如 010A -> 01 0A
     * @param str 待转换的字符串
     * @return 加空格后的字符串
     */
    public static String FormatHex(String str)
    {
        StringBuilder rtn_str = new StringBuilder();
        for (int i = 0; i < str.length(); i++)
        {
            rtn_str.append(str.charAt(i));
            if (i % 2 != 0)
            {
                rtn_str.append(" ");
            }
        }
        return rtn_str.toString().toUpperCase().trim();
    }

    /**
     * 根据长度截取字符串中的小数位数
     * @param d 数字字符串（带小数点）
     * @param len 保留的小数位数
     * @return 截取后的字符串，非小数字符串或小数位数小于len的，直接保留原字符串
     */
    public static String FormatDouble2(String d, int len)
    {
        String rtn = d;
        if ((!rtn.contains("E")) && (rtn.contains(".")))
        {
            String m = rtn.split("\\.")[1];
            if (m.length() > len)
            {
                rtn = rtn.substring(0, rtn.indexOf(".") + 1 + len);
            }
        }
        return rtn;
    }

    public static String FormatFloat(String f, int len)
    {
        String rtn;
        if (f.contains("."))
        {
            if (f.substring(f.indexOf(".")).length() < len)
            {
                if (f.contains("E")) {
                    rtn = f.substring(0, f.indexOf("E"));
                } else {
                    rtn = f;
                }
            }
            else if (f.contains("E"))
            {
                rtn = f.substring(0, f.indexOf("E"));
                if (rtn.substring(rtn.indexOf(".")).length() > len) {
                    rtn = rtn.substring(0, rtn.indexOf(".") + len + 1);
                }
            }
            else
            {
                rtn = f.substring(0, f.indexOf(".") + len + 1);
            }
        }
        else {
            rtn = f;
        }
        return rtn;
    }

    /**
     * 根据起始bit和参数所占长度bit，计算索引
     * 当参数长度=8 返回参数所在的字节号码（从0开始计算，如startBit=64 length=8，则返回W8，表明第8字节为指定的参数）；
     * 当参数长度>8 返回参数所在的所有字节号码，如果不是整字节，则返回其所占的全部字节号码
     * 当参数长度=1 返回参数所在的字节号及bit位
     * 当参数长度>1 <8 返回参数所在的字节号及所占的bit位
     * @param startBit 起始bit
     * @param lengthBit 参数所占长度
     * @return 索引 W = 字节 B = bit
     */
    public static String getTmParameterIndex(int startBit, int lengthBit)
    {
        String b = "";
        int c = (int)Math.floor(startBit / 8);
        int d = (int)Math.floor((startBit + lengthBit - 1) / 8);
        int e = 8 - startBit % 8 - 1;
        int f = 8 - (startBit + lengthBit - 1) % 8 - 1;
        if (lengthBit == 8) {
            b = "W" + c;
        } else if (lengthBit > 8) {
            b = "W" + c + "~W" + d;
        } else if (lengthBit == 1) {
            b = "W" + c + "B" + e;
        } else if (lengthBit > 1) {
            b = "W" + c + "B" + e + "~B" + f;
        }
        return b;
    }

    public static long Hex_to_Gps_Week(String hex)
    {
        long r;
        r = Long.parseLong(hex, 16);
        return r;
    }

    public static double Hex_to_Gps_Sec(String hex)
    {
        double r;
        r = Math.floor(Long.parseLong(hex, 16) / 1000L);
        return r;
    }

    public static double Hex_to_Gps_Sec_ms(String hex)
    {
        double r;
        r = Long.parseLong(hex, 16);
        return r;
    }

    public static double FormatRound(double str)
    {
        double r;
        String temp;
        temp = new BigDecimal(str).toPlainString();
        if (temp.contains("."))
        {
            temp = temp.substring(0, temp.indexOf("."));
        }
        r = Double.parseDouble(temp);
        return r;
    }

    public static String WeekMs_to_UTC(String weekMs)
    {
        double week = 0.0D;
        double sec = 0.0D;
        double tiao_sec = 17.0D;
        double tmp2 = 0.0D;
        if ((weekMs != null) && (!"".equals(weekMs)) && (weekMs.length() > 7))
        {
            week = Hex_to_Gps_Week(weekMs.substring(0, 4));
            sec = Hex_to_Gps_Sec(weekMs.substring(4));
            tmp2 = Hex_to_Gps_Sec_ms(weekMs.substring(4));
        }
        double tmp = sec;
        if (sec - tiao_sec < 0.0D)
        {
            week -= 1.0D;
            sec = sec - tiao_sec + 604800.0D;
        }
        else
        {
            sec -= tiao_sec;
        }
        double h = week * 7.0D + sec / 86400.0D + 44244.0D + 2400000.5D + 0.5D;

        double i = FormatRound(h);
        double j = i + 68569.0D;
        double k = FormatRound(j * 4.0D / 146097.0D);
        double l = j - FormatRound((k * 146097.0D + 3.0D) / 4.0D);
        double m = FormatRound((l + 1.0D) * 4000.0D / 1461001.0D);
        double n = l - FormatRound(m * 1461.0D / 4.0D) + 31.0D;
        double o = FormatRound(n * 80.0D / 2447.0D);
        double p = FormatRound(o / 11.0D);
        double t = h % 1.0D * 24.0D;
        double u = FormatRound(h % 1.0D * 24.0D);
        double v = (t - u) * 60.0D;
        double w = FormatRound((t - u) * 60.0D);
        String ms;
        String year = String.valueOf(FormatRound(100.0D * (k - 49.0D)) + m + p);
        year = year.substring(0, year.indexOf("."));
        String mon = String.valueOf(FormatRound(o + 2.0D - 12.0D * p));
        mon = mon.substring(0, mon.indexOf("."));
        String day = String.valueOf(n - FormatRound(2447.0D * o / 80.0D));
        day = day.substring(0, day.indexOf("."));
        String hour = String.valueOf(FormatRound(h % 1.0D * 24.0D));
        hour = hour.substring(0, hour.indexOf("."));
        String min = String.valueOf(FormatRound((t - u) * 60.0D));
        min = min.substring(0, min.indexOf("."));
        DecimalFormat df = new DecimalFormat("###########");
        DecimalFormat df2 = new DecimalFormat("###########.000");
        String s = String.valueOf(df.format((v - w) * 60.0D));
        tmp2 = Double.parseDouble(df2.format(tmp2 / 1000.0D));
        ms = df.format((tmp2 - tmp) * 1000.0D);
        return year + "-" + mon + "-" + day + " " + hour + ":" + min + ":" + s + "." + ms;
    }

    /**
     * 原码字符串转换
     * @param message 原码 二进制 字符串
     * @param code 原码处理类型：0:无符号; 1:有符号; 2:补码; 3:反码
     * @return 转换完成的字符串(补码和反码转换忽略符号位)
     */
    public static String TransForm_OriginalType(String message, int code)
    {
        StringBuffer rtn = new StringBuffer(message);
        switch (code)
        {
//            无符号直接返回
            case 0:
                break;
//            有符号，如果是1，则直接加负号
            case 1:
                if (message.charAt(0) == '1')
                {
                    rtn = new StringBuffer("-" + message.substring(1));
                }
                break;
//            补码
            case 2:
                rtn = new StringBuffer(Get_Binary_Bm(message));
                break;
//            反码
            case 3:
                rtn = new StringBuffer(Get_Binary_Fm(message));
                break;
            case 4:
                rtn = new StringBuffer(Hex_to_Binary(LowUp(Binary_to_Hex(message))));
                rtn = new StringBuffer(FullStr0(rtn.toString(), message.length()));
                if (rtn.substring(0, 1).equals("1"))
                {
                    rtn = new StringBuffer("-" + rtn.substring(1, rtn.length()));
                }
                break;
            case 5:
                rtn = new StringBuffer(Binary_to_Hex(message));
                rtn = new StringBuffer(AsciiStringToString(rtn.toString()));
                rtn = new StringBuffer(Hex_to_Binary(rtn.toString()));
        }
        return rtn.toString();
    }

    /**
     * 遥测解析处理
     * @param message 遥测原码二进制字符串
     * @param code 解析方法代码 0:原码; 1:十进制; 2:公式; 3:状态码(十六进制);4:状态码(十进制);5:状态码(二进制); 6:时间; 7:不处理;8:32位单精度浮点数
     * @param analyticPara 解析参数
     * @param symbol 负号
     * @return 处理后的字符串
     */
    public static String TransForm_AnalyticType(String message, int code, String analyticPara, int symbol)
    {
        StringBuffer rtn = new StringBuffer(message);
        try
        {
            FuncMap funcMap;
            DecimalFormat df;
            double x;
//            存储状态码解析方法的字符串数组；例：第一个元素：55=是 第二个元素：AA=否
            String[] arrayOfString;
            switch (code)
            {
//                原码，将二进制字符串转换为16进制，再按字节加空格
                case 0:
                case 16:
                    rtn = new StringBuffer(FormatHex(Binary_to_Hex(message)));
                    break;
//                十进制
                case 1:
                    rtn = new StringBuffer(Binary_to_Dec(message));
                    break;
//                公式
                case 2:
                    if (analyticPara.contains("Sign"))
                    {
                        analyticPara = Double.parseDouble(Binary_to_Dec(message)) >= 0.0D ? analyticPara.replace("Sign(x)", "") : analyticPara.replace("Sign(x)", "-");
                    }
                    if (analyticPara.equals(""))
                    {
                        rtn = new StringBuffer();
                    } else
                    {
                        try
                        {
//                            将工程值处理参数传入，并创建对象，就是给公式添加括号，同时分解parent和leftChild，rightChild
                            Expression expression = ExpressionTree.parse(analyticPara);
//                            变量Map的创建
                            VarMap varMap = new VarMap();
//                            函数Map的创建
                            funcMap = new FuncMap();
//                            函数Map加载默认的33个函数
                            funcMap.loadDefaultFunctions();
//                            将二进制字符串的遥测参数 -》 十进制 -》 double用于计算
                            x = Double.parseDouble(Binary_to_Dec(message));
                            if (symbol == 1)
                            {
                                x = 0.0D - x;
                            }
//                            给变量Map中的“x”变量赋值
                            varMap.setValue("x", x);
//                            创建格式化字符串，即保留8位小数，预留符号位
                            df = new DecimalFormat("###0.00000000");
                            Double dd = expression.eval(varMap, funcMap);
//                            是否为非数值
                            if (dd.toString().equals("NaN"))
                            {
                                rtn = new StringBuffer(dd.toString());
                            } else
                            {
                                rtn = new StringBuffer(df.format(expression.eval(varMap, funcMap)));
                            }
                        }
                        catch (Exception e)
                        {
                            rtn = new StringBuffer("NaN");
                        }
                    }
                    break;
//                状态码(十六进制)
                case 3:
//                    将遥测参数二进制原码转换为16进制字符串
                    String hex_code = Binary_to_Hex(message);
//                    计算一共有多少种解析方法，即多少个解析参数
                    x = (arrayOfString = analyticPara.split(";")).length;
//                    遍历所有的解析参数
                    for (int i = 0; i < x; i++)
                    {
//                        取出各组 原码=解析值 字符串；例：55=是
                        String s = arrayOfString[i];
//                        原码的十六进制 有对应的解析方法
                        if (s.split("=")[0].trim().equals(hex_code))
                        {
                            if (s.split("=").length <= 1) {
                                break;
                            }
//                            取出原码对应的解析值
                            rtn = new StringBuffer(s.split("=")[1]);
//                            结束循环
                            break;
                        }
                    }
//                    没有找到对应的状态码
                    if (rtn.toString().equals(message))
                    {
//                        再查找是否有状态码参数为“其他”
                        rtn = new StringBuffer("无对应状态码");
                        x = (arrayOfString = analyticPara.split(";")).length;
                        for (int i = 0; i < x; i++)
                        {
                            String s = arrayOfString[i];
                            if (s.split("=")[0].trim().equals("其他"))
                            {
                                if (s.split("=").length <= 1) {
                                    break;
                                }
                                rtn = new StringBuffer(s.split("=")[1]);

                                break;
                            }
                        }
                    }
                    break;
//                状态码(十进制)
                case 4:
                    String dec_code = Binary_to_Dec(message);
//                    计算一共有多少种解析方法，即多少个解析参数
                    x = (arrayOfString = analyticPara.split(";")).length;
//                    遍历所有的解析参数
                    for (int i = 0; i < x; i++)
                    {
                        String s = arrayOfString[i];
                        if ((s.split("=")[0].trim().equals(dec_code)) && (s.length() > 1))
                        {
                            if (s.split("=").length <= 1)
                            {
                                break;
                            }
                            rtn = new StringBuffer(s.split("=")[1]);
                            break;
                        }
                    }
                    if (rtn.toString().equals(message))
                    {
                        rtn = new StringBuffer("无对应状态码");
                        x = (arrayOfString = analyticPara.split(";")).length;
                        for (int i = 0; i < x; i++)
                        {
                            String s = arrayOfString[i];
                            if (s.split("=")[0].trim().equals("其他"))
                            {
                                if (s.split("=").length <= 1) {
                                    break;
                                }
                                rtn = new StringBuffer(s.split("=")[1]);
                                break;
                            }
                        }
                    }
                    break;
//                状态码(二进制)
                case 5:
//                    计算一共有多少种解析方法，即多少个解析参数
                    x = (arrayOfString = analyticPara.split(";")).length;
//                    遍历所有的解析参数
                    for (int i = 0; i < x; i++)
                    {
                        String s = arrayOfString[i];
                        if (s.split("=")[0].trim().equals(message))
                        {
                            if (s.split("=").length <= 1) {
                                break;
                            }
                            rtn = new StringBuffer(s.split("=")[1]);
                            break;
                        }
                    }
                    if (rtn.toString().equals(message))
                    {
                        rtn = new StringBuffer("无对应状态码");
                        x = (arrayOfString = analyticPara.split(";")).length;
                        for (int i = 0; i < x; i++)
                        {
                            String s = arrayOfString[i];
                            if (s.split("=")[0].trim().equals("其他"))
                            {
                                if (s.split("=").length <= 1) {
                                    break;
                                }
                                rtn = new StringBuffer(s.split("=")[1]);

                                break;
                            }
                        }
                    }
                    break;
//                6:时间
                case 6:
                    if (message.length() == 48)
                    {
                        String week = FullBinary(Binary_to_Hex(message.substring(0, 16)), 4);
                        String ms = FullBinary(Binary_to_Hex(message.substring(16)), 8);
                        rtn = new StringBuffer(WeekMs_to_UTC(week + ms));
                    }
                break;
//                7:不处理
                case 7:
                    break;
//                8:32位单精度浮点数
                case 8:
                    if ((analyticPara == null) || ("".equals(analyticPara.trim())) || ("X".equalsIgnoreCase(analyticPara.trim())))
                    {
                        try
                        {
                            rtn = new StringBuffer(new BigDecimal(Hex_to_Float(Binary_to_Hex(message.trim()))).toString());
                        }
                        catch (NumberFormatException e)
                        {
                            rtn = new StringBuffer(String.valueOf(Hex_to_Float(Binary_to_Hex(message.trim()))));
                        }
                    }
                    else if ((analyticPara.trim().toUpperCase().contains("X")) && (analyticPara.trim().length() > 2))
                    {
                        String rtn_float = new BigDecimal(Hex_to_Float(Binary_to_Hex(message.trim()))).toString();
                        if (rtn_float.contains("E")) {
                            rtn_float = rtn_float.substring(0, rtn_float.indexOf("E"));
                        }
                        double d;
                        d = Double.parseDouble(rtn_float);
                        Expression expression1 = ExpressionTree.parse(analyticPara.trim().toUpperCase());
                        VarMap vm1 = new VarMap();
                        FuncMap fmm1 = new FuncMap();
                        fmm1.loadDefaultFunctions();
                        if (symbol == 1) {
                            d = 0.0D - d;
                        }
                        vm1.setValue("X", d);
                        rtn = new StringBuffer(new BigDecimal(expression1.eval(vm1, fmm1)).toString());
                    }
                    break;
                case 9:
                    float rtn_float = Hex_to_Float(Binary_to_Hex(message));
                    if (analyticPara.equals(""))
                    {
                        rtn = new StringBuffer();
                    }
                    else
                    {
                        Expression expression1 = ExpressionTree.parse(analyticPara);
                        VarMap vm1 = new VarMap();
                        FuncMap fmm1 = new FuncMap();
                        fmm1.loadDefaultFunctions();
                        vm1.setValue("x", rtn_float);
                        rtn = new StringBuffer(String.valueOf(expression1.eval(vm1, fmm1)));
                    }
                    break;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
            rtn = new StringBuffer(message);
        }
//        rtn为最后的解析值
        return rtn.toString();
    }
}
